home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 November: Tool Chest / Dev.CD Nov 96 TC / Dev.CD Nov 96 TC.toast / Sample Code / Interapplication Communication / MenuScripter 4.0 / Sources / MSAETextUtils.c < prev    next >
Encoding:
Text File  |  1996-07-09  |  17.9 KB  |  767 lines  |  [TEXT/CWIE]
  1. // MSAETextUtils.c
  2. //
  3. // Original version by Jon Lansdell and Nigel Humphreys.
  4. // 4.0 and 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1996, all rights reserved.
  6.  
  7. /*
  8.     14-Nov-95 : GS : Removed reliance on compiler setting local variable to zero
  9.                         in GetInsertDescFromInsertHere().
  10. */
  11.  
  12. #include "MSAETextUtils.h"
  13.  
  14. #include "MSAEUtils.h"
  15. #include "MSWindow.h"        // for DPtrFromWindowPtr()
  16. #include "MSAERecording.h"
  17.  
  18.  
  19. #include <AEPackObject.h>
  20.  
  21.  
  22.  
  23. // ----------------------------------------------------------------------------------
  24. //    Name:    PutStyledTextFromDescIntoTEHandle
  25. //    Purpose: Takes the text in an AEDesc containing typeIntlText and puts it in
  26. //             a styled text edit record at the current insertion point.
  27. //                     Looks for typeIntlText, typeStyledText, typeChar in that order.
  28. // ----------------------------------------------------------------------------------
  29.  
  30. OSErr    PutStyledTextFromDescIntoTEHandle(const AEDesc *sourceTextDesc, TEHandle theHTE)
  31. {
  32.     AEDesc styledTextDesc = { typeNull, NULL };
  33.     AEDesc textStyleDesc = { typeNull, NULL };
  34.     AEDesc rawTextDesc = { typeNull, NULL };
  35.     OSErr  myErr;
  36.     
  37.     //    Coerce to an AERecord and then extract the parts of the
  38.     //    styled text - works for typeIntlText, typeStyledText
  39.  
  40.     myErr = AECoerceDesc(sourceTextDesc, typeAERecord, &styledTextDesc);
  41.     
  42.     if (noErr == myErr)
  43.     {        
  44.         myErr = AEGetKeyDesc(&styledTextDesc,  keyAEText,
  45.                                             typeChar, &rawTextDesc);
  46.                                                  
  47.         myErr = AEGetKeyDesc(&styledTextDesc,  keyAEStyles,
  48.                                             typeScrapStyles, &textStyleDesc);
  49.     }
  50.     else
  51.     {
  52.         myErr = AECoerceDesc(sourceTextDesc, typeChar, &rawTextDesc);
  53.         
  54.         textStyleDesc.dataHandle = NULL; // so that TEStylInsert acts like TEInsert                
  55.     }
  56.             
  57.     HLock((Handle)rawTextDesc.dataHandle);
  58.     
  59.     TEDelete(theHTE);                    // Insert over current selection
  60.     TEStylInsert((const void *) (*rawTextDesc.dataHandle),
  61.                                          GetHandleSize(rawTextDesc.dataHandle),
  62.                                              (StScrpHandle) textStyleDesc.dataHandle,
  63.                                                  theHTE);
  64.                              
  65.     HUnlock((Handle)rawTextDesc.dataHandle);
  66.     
  67.     (void)AEDisposeDesc(&textStyleDesc);
  68.     (void)AEDisposeDesc(&rawTextDesc);
  69.     (void)AEDisposeDesc(&styledTextDesc);
  70.         
  71.     return(myErr);
  72. }
  73.  
  74.  
  75. TEHandle    TEHandleFromWindow(WindowPtr theWindow)
  76. {
  77.     DPtr        docPtr;
  78.     TEHandle    result = NULL;
  79.     
  80.     if (! theWindow)
  81.         return(NULL);
  82.     
  83.     docPtr = DPtrFromWindowPtr(theWindow);
  84.     
  85.     if (docPtr)
  86.         result = docPtr->theText;
  87.         
  88.     return(result);
  89. }
  90.  
  91. TEHandle    TEHandleFromTextToken(TextToken* aToken)
  92. {
  93.     if (! aToken)
  94.         return(NULL);
  95.         
  96.     return(TEHandleFromWindow(aToken->tokenWindow));
  97. }
  98.  
  99.  
  100. OSErr    GetInsertDescFromInsertHere(AEDesc* insertHereDesc, AEDesc* insertDesc, DescType* insertType)
  101. {
  102.     AEDesc        insertRec = {typeNull, NULL},
  103.                 objectSpec = {typeNull, NULL};
  104.     DescType    returnedType;
  105.     Size        actualSize;
  106.     OSErr        err = noErr;
  107.  
  108.      switch (insertHereDesc->descriptorType)
  109.      {
  110.          case typeInsertionLoc:
  111.              err = AECoerceDesc(insertHereDesc, typeAERecord, &insertRec);
  112.              if (noErr != err) goto done;
  113.              
  114.              err = AEGetKeyPtr(&insertRec, keyAEPosition, typeEnumeration, &returnedType,
  115.                                          (Ptr)insertType, sizeof(insertType), &actualSize);
  116.              if (noErr != err) goto done;
  117.  
  118.             err = AEGetKeyDesc(&insertRec, keyAEObject, typeWildCard, &objectSpec);
  119.             if (objectSpec.descriptorType != typeNull)
  120.             {
  121.                 err = AEResolve(&objectSpec, kAEIDoMinimum, insertDesc);
  122.                 if (err != noErr) goto done;
  123.             }
  124.              break;
  125.      
  126.          case typeObjectSpecifier:
  127.              err = AEResolve(insertHereDesc, kAEIDoMinimum, insertDesc);
  128.              if (noErr != err) goto done;
  129.              *insertType = insertDesc->descriptorType;
  130.              break;
  131.              
  132.          case typeNull:                    // No insertion location given
  133.              *insertType = typeNull;
  134.              break;
  135.              
  136.          case typeType:
  137.              *insertType = *(DescType *)*insertHereDesc->dataHandle;
  138.              break;
  139.              
  140.          default:                        // Just copy the descriptor
  141.              err = AEDuplicateDesc(insertHereDesc, insertDesc);
  142.              if (noErr != err) goto done;
  143.              *insertType = insertDesc->descriptorType;
  144.      }
  145.      
  146.  done:
  147.      if (insertRec.dataHandle)
  148.          AEDisposeDesc(&insertRec);
  149.      if (objectSpec.dataHandle)
  150.          AEDisposeDesc(&objectSpec);
  151.      
  152.      return(err);
  153. }
  154.  
  155. // This routine returns an enumerated type describing the relative position
  156. // of one TextToken to another.
  157.  
  158. TokenWithinType    TokenWithinToken(TextToken* container, TextToken* token, short* numPartial)
  159. {
  160.     TokenWithinType        result;
  161.  
  162.     if (token->tokenOffset + token->tokenLength < container->tokenOffset)
  163.         result = kTokenBefore;
  164.     else if (container->tokenOffset + container->tokenLength < token->tokenOffset)
  165.         result = kTokenAfter;
  166.     else if (token->tokenOffset >= container->tokenOffset
  167.                 && token->tokenOffset + token->tokenLength <= container->tokenOffset + container->tokenLength)
  168.         result = kTokenWithin;
  169.     else if (token->tokenOffset < container->tokenOffset)
  170.     {
  171.         result = kTokenPartialBefore;
  172.         if (numPartial)
  173.             *numPartial = token->tokenOffset + token->tokenLength - container->tokenOffset;
  174.     }
  175.     else
  176.     {
  177.         result = kTokenPartialAfter;
  178.         if (numPartial)
  179.             *numPartial = container->tokenOffset + container->tokenLength - token->tokenOffset;
  180.     }
  181.     
  182.     return(result);
  183. }
  184.  
  185.  
  186. OSErr    TextTokenFromDocumentToken(WindowToken* theWindowToken, TextToken* theTextToken)
  187. {
  188.     DPtr        docPtr;
  189.  
  190.     docPtr = DPtrFromWindowPtr(theWindowToken->tokenWindow);
  191.  
  192.     if (! docPtr)
  193.         return(errAENoSuchObject);
  194.             // Create our text token
  195.     theTextToken->tokenWindow = theWindowToken->tokenWindow;    
  196.     theTextToken->tokenOffset = 1;                                // Start at 1
  197.     theTextToken->tokenLength = (**docPtr->theText).teLength;    // through whole length
  198.     
  199.     return(noErr);
  200. }
  201.  
  202.  
  203. OSErr    TextTokenFromDocumentDesc(AEDesc* windowDesc, TextToken* theToken)
  204. {
  205.     AEDesc            aDesc = {typeNull, NULL};
  206.     WindowToken        aWindowToken;
  207.     Size            actualSize;
  208.     OSErr            err;
  209.     
  210.     err = AECoerceDesc(windowDesc, typeMyDocument, &aDesc);
  211.     if (noErr != err) goto done;
  212.         
  213.     GetRawDataFromDescriptor(&aDesc, (Ptr)&aWindowToken,
  214.                                     sizeof(aWindowToken), &actualSize);
  215.  
  216.     err = TextTokenFromDocumentToken(&aWindowToken, theToken);
  217.     
  218. done:    
  219.     (void)AEDisposeDesc(&aDesc);
  220.  
  221.     return(err);
  222. }
  223.  
  224.  
  225. OSErr    TextDescFromDocumentToken(WindowToken* theWindowToken, AEDesc* textDesc)
  226. {
  227.     TextToken    aToken;
  228.     OSErr        err;
  229.     
  230.     err = TextTokenFromDocumentToken(theWindowToken, &aToken);
  231.     if (noErr != err) goto done;
  232.     
  233.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  234.  
  235. done:
  236.     return(err);
  237. }
  238.  
  239.  
  240. OSErr    TextDescFromDocumentDesc(AEDesc* windowDesc, AEDesc* textDesc)
  241. {
  242.     TextToken    aToken;
  243.     OSErr        err;
  244.     
  245.     err = TextTokenFromDocumentDesc(windowDesc, &aToken);
  246.     if (noErr != err) goto done;
  247.     
  248.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  249.  
  250. done:
  251.     return(err);
  252. }
  253.  
  254.  
  255. void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  256.     // Treats space, comma, full stop, ; and : as space chars
  257. { 
  258.     short x;
  259.  
  260.     while (*start <= limit) {
  261.       x = (**myChars)[*start];
  262.         if (IsWhiteSpace(x))
  263.             (*start) +=1;
  264.         else
  265.             return;
  266.     }
  267. }
  268.     
  269. void    MoveToSpace(short *start, short limit, charsHandle myChars)
  270.     // Treats space,comma, full stop, ; and : as space chars
  271. { 
  272.     short x;
  273.     
  274.     while (*start <= limit)
  275.     {
  276.         x = (**myChars)[*start];
  277.         if (! IsWhiteSpace(x))
  278.             (*start)++;
  279.         else
  280.             return;
  281.     }
  282. }
  283.  
  284. void    MoveToEndOfParagraph(short *start, short limit, charsHandle myChars)
  285.     //    Treats CR as end of paragraph
  286. { 
  287.     short x;
  288.     
  289.     while (*start <= limit)
  290.     {
  291.         x = (**myChars)[*start];
  292.         if (! IsParagraphDelimiter(x))        // had x != CR
  293.             (*start)++;
  294.         else
  295.             return;
  296.     }
  297. }
  298.  
  299.  
  300. // This routine counts the given elementType between startAt and 
  301.  
  302. OSErr    CountTextElements(TEHandle inTextHandle, short startAt,
  303.                                 short forHowManyChars, DescType elementType, short* result)
  304. {
  305.     charsHandle    theChars;
  306.     short       limit,
  307.                 start;
  308.     OSErr        err = noErr;
  309.  
  310.     switch (elementType)
  311.     {
  312.         case cInsertionPoint:    // Always one more insertion location than characters
  313.             *result = forHowManyChars + 1;
  314.             break;
  315.             
  316.         case cChar:            // Easy
  317.             *result = forHowManyChars;
  318.             break;
  319.             
  320.         case cText:    
  321.             *result = 1;
  322.             break;
  323.         
  324.         case cWord:            // Cycle through - counting
  325.         case cParagraph:
  326.             theChars = (charsHandle)(**inTextHandle).hText;
  327.             start = startAt - 1;                    // Convert to zero based
  328.             limit = start + forHowManyChars - 1;    // when passed one based
  329.             *result    = 0;
  330.             MoveToNonSpace(&start, limit, theChars);
  331.             while (start <= limit)
  332.             {
  333.                 (*result)++;
  334.                 switch (elementType)
  335.                 {
  336.                     case cWord:
  337.                         MoveToSpace(&start, limit, theChars);
  338.                         break;
  339.                         
  340.                     case cParagraph:
  341.                         MoveToEndOfParagraph(&start, limit, theChars);
  342.                         break;
  343.                 }
  344.                 MoveToNonSpace(&start, limit, theChars);
  345.             }
  346.             break;
  347.     
  348.         default:
  349.             *result = -1;
  350.             err = errAEBadKeyForm;
  351.     }
  352.     
  353.     return(err);
  354. } // CountTextElements
  355.  
  356. OSErr    GetDescOfNthTextElement(short index, DescType elementType,
  357.                                         TextToken* containerToken, AEDesc* result)
  358. {
  359.     DPtr        docPtr;
  360.     TextToken    theToken;
  361.     short        start,
  362.                 maxChars,
  363.                 elementCount,
  364.                 limit,
  365.                 elementStart;
  366.     charsHandle    theChars;
  367.     OSErr        err;
  368.     
  369.     if (! containerToken)
  370.         return(errAEEmptyListContainer);
  371.  
  372.     docPtr = DPtrFromWindowPtr(containerToken->tokenWindow);
  373.     start = containerToken->tokenOffset - 1;    // Zero based
  374.     maxChars = containerToken->tokenLength;
  375.  
  376.     err = CountTextElements(docPtr->theText, containerToken->tokenOffset,
  377.                                         maxChars, elementType, &elementCount);
  378.     if (noErr != err) return(err);
  379.     
  380.     if (index < 0)                        // Change a negative index to positive
  381.         index = elementCount + index + 1;
  382.         
  383.     if (index > elementCount)            // Got given an index out of range
  384.         return(errAEIllegalIndex);
  385.         
  386.             // Set the window that the token relates to
  387.     theToken.tokenWindow = containerToken->tokenWindow;
  388.  
  389.     switch (elementType)
  390.     {
  391.         case cInsertionPoint:
  392.             theToken.tokenOffset = start + index - 1;
  393.             theToken.tokenLength = 0;
  394.             break;
  395.             
  396.         case cChar:        // Easy - just the start point + the index
  397.             theToken.tokenOffset = start + index;
  398.             theToken.tokenLength = 1;
  399.             break;
  400.             
  401.         case cText:    
  402.             theToken.tokenOffset = start + index;
  403.             theToken.tokenLength = maxChars;
  404.             break;
  405.             
  406.         case cWord:
  407.         case cParagraph:
  408.             theChars = (charsHandle)(**(docPtr->theText)).hText;
  409.             limit = start + maxChars - 1;
  410.             MoveToNonSpace(&start, limit, theChars);
  411.             while ((start <= limit) && (index > 0))
  412.             {
  413.                 index--;
  414.                 elementStart = start;
  415.                 switch (elementType)
  416.                 {
  417.                     case cWord:
  418.                         MoveToSpace(&start, limit, theChars);
  419.                         break;
  420.                         
  421.                     case cParagraph:
  422.                         MoveToEndOfParagraph(&start, limit, theChars);
  423.                         break;
  424.                 }
  425.                 theToken.tokenLength = start - elementStart;
  426.                 MoveToNonSpace(&start, limit, theChars);
  427.             }
  428.             theToken.tokenOffset = elementStart + 1;    // Convert to one based
  429.             break;
  430.     }
  431.  
  432.     err = AECreateDesc(typeMyText, (Ptr)&theToken, sizeof(theToken), result);
  433.  
  434.     return(err);
  435. }
  436.  
  437.  
  438. char    GetTEHChar(TEHandle aTEH, short offset)
  439. {
  440.     char    result;
  441.     
  442.     offset--;        // This is now 0 based
  443.  
  444.     if (offset < 0 || offset >= (*aTEH)->teLength)
  445.         return('\0');
  446.         
  447.     result = *(char *)((*(**aTEH).hText) + offset);
  448.     
  449.     return(result);
  450. }
  451.  
  452. Boolean        IsAtStart(TextToken* theToken)
  453. {
  454.     Boolean    result;
  455.                     // Is at start if offset is at 1
  456.     result = (theToken->tokenOffset == 1);
  457.     
  458.     return(result);
  459. }
  460.  
  461. Boolean        IsAtEnd(TextToken* theToken)
  462. {
  463.     TEHandle    aTEH;
  464.     Boolean        result;
  465.     
  466.     aTEH = TEHandleFromTextToken(theToken);
  467.                     // Does it go to the end?
  468.     result = (theToken->tokenOffset + theToken->tokenLength >= (**aTEH).teLength);
  469.     
  470.     return(result);
  471. }
  472.  
  473. Boolean        IsWhiteSpace(short aChar)
  474. {
  475.     Boolean    result;
  476.  
  477.     result = (aChar == ' ' || aChar == ',' || aChar == '.'
  478.                 || aChar == ':' || aChar == LF || aChar == CR);
  479.              
  480.     return(result);
  481. }
  482.  
  483. Boolean        IsParagraphDelimiter(short aChar)
  484. {
  485.     Boolean    result;
  486.  
  487.     result = (aChar == CR);
  488.              
  489.     return(result);
  490. }
  491.  
  492. Boolean        IsContentsToken(TextToken* theToken)
  493. {
  494.     return(IsAtStart(theToken) && IsAtEnd(theToken));
  495. }
  496.  
  497. Boolean        IsParagraphToken(TextToken* theToken, short* start, short* end)
  498. {
  499.     TEHandle    aTEH;
  500.     OSErr        err;
  501.     short        number;
  502.     Boolean        fStart,
  503.                 fEnd,
  504.                 result;
  505.     
  506.     aTEH = TEHandleFromTextToken(theToken);
  507.         
  508.     fStart = IsAtStart(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  509.     fEnd = IsAtEnd(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  510.     
  511.     if (fStart && fEnd)
  512.     {
  513.         // need to do a count of the paragraphs
  514.         
  515.         err = CountTextElements(aTEH, theToken->tokenOffset,
  516.                             theToken->tokenLength, cParagraph, &number);
  517.  
  518.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  519.         
  520.         if (IsAtStart(theToken))
  521.             *start = 1;
  522.         else
  523.         {                // From beginning to charracter before start of paragraph
  524.             err = CountTextElements(aTEH, 1,theToken->tokenOffset - 1, cParagraph, start);
  525.             (*start)++;
  526.         }
  527.         
  528.         *end = *start + number - 1;
  529.         
  530.         result = true;
  531.     }
  532.     else
  533.         result = false;
  534.     
  535.     return(result);
  536. }
  537.  
  538. Boolean        IsWordToken(TextToken* theToken, short* start, short* end)
  539. {
  540.     TEHandle    aTEH;
  541.     OSErr        err;
  542.     short        number;
  543.     Boolean        fStart,
  544.                 fEnd,
  545.                 result;
  546.         
  547.     aTEH = TEHandleFromTextToken(theToken);
  548.         
  549.     fStart = IsAtStart(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  550.     fEnd = IsAtEnd(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  551.     
  552.     if (fStart && fEnd)
  553.     {
  554.         // need to do a count of the words
  555.         
  556.         err = CountTextElements(aTEH, theToken->tokenOffset,
  557.                             theToken->tokenLength, cWord, &number);
  558.  
  559.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  560.         
  561.         if (IsAtStart(theToken))
  562.             *start = 1;
  563.         else
  564.         {                // From beginning to charracter before start of word
  565.             err = CountTextElements(aTEH, 1, theToken->tokenOffset - 1, cWord, start);
  566.             (*start)++;
  567.         }
  568.         
  569.         *end = *start + number - 1;
  570.         
  571.         result = true;
  572.     }
  573.     else
  574.         result = false;
  575.     
  576.     return(result);
  577. }
  578.  
  579.  
  580. DescType    GetTextTokenType(TextToken* theToken, short* start, short* end)
  581. {
  582.     DescType    result;
  583.     
  584.     *start = *end = -1;                    // Just set to the same value
  585.  
  586.     if (! theToken->tokenLength)
  587.     {
  588.         result = cInsertionPoint;
  589.     }
  590.     else if (IsContentsToken(theToken))
  591.     {
  592.         result = pContents;
  593.     }
  594.     else if (IsParagraphToken(theToken, start, end))
  595.     {
  596.         result = cParagraph;
  597.     }
  598.     else if (IsWordToken(theToken, start, end))
  599.     {
  600.         result = cWord;
  601.     }
  602.     else
  603.     {
  604.         result = cChar;
  605.         *start = theToken->tokenOffset;
  606.         *end = theToken->tokenOffset + theToken->tokenLength - 1;
  607.     }
  608.     
  609.     return(result);
  610. }
  611.  
  612. OSErr    MakeContentsSpecifier(TextToken* theToken, AEDesc* result)
  613. {
  614.     AEDesc        docSpec = {typeNull, NULL},
  615.                 contentsDesc = {typeNull, NULL};
  616.     DescType    propertyID;
  617.     OSErr        err;
  618.  
  619.     err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  620.     if (noErr != err) goto done;
  621.     
  622.     propertyID = pContents;
  623.     err = AECreateDesc(typeType, (Ptr)&propertyID, sizeof(DescType), &contentsDesc);
  624.     if (err != noErr) goto done;
  625.     err = CreateObjSpecifier(cProperty, &docSpec, formPropertyID, &contentsDesc, false, result);
  626.  
  627. done:
  628.     (void)AEDisposeDesc(&docSpec);
  629.     (void)AEDisposeDesc(&contentsDesc);
  630.     
  631.     return(err);
  632. }
  633.  
  634.  
  635. OSErr    MakeAbsoluteTextSpecifier(WindowPtr theWindow, DescType textType, long index, AEDesc* result)
  636. {
  637.     AEDesc        docSpec = {typeNull, NULL},
  638.                 absoluteDesc = {typeNull, NULL};
  639.     OSErr        err;
  640.     
  641.     if (theWindow)
  642.     {
  643.         err = MakeDocumentObj(theWindow, &docSpec);
  644.         if (noErr != err) goto done;
  645.     }
  646.     // else just use the NULL'ed value
  647.  
  648.     err = AECreateDesc(typeLongInteger, (Ptr)&index, sizeof(index), &absoluteDesc);
  649.     if (err != noErr) goto done;
  650.     err = CreateObjSpecifier(textType, &docSpec, formAbsolutePosition,
  651.                                                     &absoluteDesc, false, result);
  652.  
  653. done:
  654.     (void)AEDisposeDesc(&docSpec);
  655.     (void)AEDisposeDesc(&absoluteDesc);
  656.     
  657.     return(err);
  658. }
  659.  
  660.  
  661. OSErr    MakeInsertionPointSpecifier(TextToken* theToken, AEDesc* result)
  662. {
  663.     AEDesc        relativeToSpec = {typeNull, NULL},
  664.                 relativeDesc = {typeNull, NULL};
  665.     DescType    relativeType;
  666.     OSErr        err;
  667.  
  668.     if (IsAtStart(theToken))            // Before contents (whether there are any or not)
  669.     {
  670.         relativeType = kAEPrevious;
  671.         err = MakeContentsSpecifier(theToken, &relativeToSpec);
  672.     }
  673.     else if (IsAtEnd(theToken))            // After last character
  674.     {
  675.         relativeType = kAENext;
  676.         //err = MakeContentsSpecifier(theToken, &relativeToSpec);
  677.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, -1, &relativeToSpec);
  678.     }
  679.     else                                // Has a character it can go before
  680.     {
  681.         relativeType = kAEPrevious;
  682.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, theToken->tokenOffset, &relativeToSpec);
  683.     }
  684.  
  685.     if (noErr != err) goto done;
  686.     
  687.       err = AECreateDesc(typeEnumerated, &relativeType, sizeof(relativeType), &relativeDesc);
  688.     if (noErr != err) goto done;
  689.     err = CreateObjSpecifier(cInsertionPoint, &relativeToSpec, formRelativePosition,
  690.                                                                    &relativeDesc, false, result);
  691.  
  692. done:
  693.     (void)AEDisposeDesc(&relativeToSpec);
  694.     (void)AEDisposeDesc(&relativeDesc);
  695.  
  696.     return(err);
  697. }
  698.  
  699. OSErr    GetIndexSpecifier(TextToken* theToken, DescType textType, long index, AEDesc* result)
  700. {
  701.     OSErr    err;
  702.  
  703.     switch (textType)
  704.     {
  705.         case cInsertionPoint:
  706.             err = MakeInsertionPointSpecifier(theToken, result);
  707.             break;
  708.             
  709.         case pContents:
  710.             err = MakeContentsSpecifier(theToken, result);
  711.             break;
  712.             
  713.         case cParagraph:
  714.         case cWord:
  715.         case cChar:
  716.             err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, textType, index, result);
  717.             break;
  718.         
  719.         default:
  720.             err = errAETypeError;
  721.     }
  722.     
  723.     return(err);
  724. }
  725.  
  726.  
  727. OSErr    GetTextTokenObjectSpecifier(TextToken* theToken, AEDesc* result)
  728. {
  729.     AEDesc        docSpec = {typeNull, NULL},
  730.                 startSpec = {typeNull, NULL},
  731.                 endSpec = {typeNull, NULL},
  732.                 rangeDesc = {typeNull, NULL};
  733.     DescType    textType;
  734.     short        start,
  735.                 end;
  736.     OSErr        err;
  737.     
  738.     textType = GetTextTokenType(theToken, &start, &end);
  739.     
  740.     err = GetIndexSpecifier(theToken, textType, start, &startSpec);
  741.     if (noErr != err) goto done;
  742.  
  743.     if (start != end)        // Sort out rest of range specifier
  744.     {
  745.         err = GetIndexSpecifier(theToken, textType, end, &endSpec);
  746.         if (noErr != err) goto done;
  747.         
  748.         err = CreateRangeDescriptor(&startSpec, &endSpec, false, &rangeDesc);
  749.         if (noErr != err) goto done;
  750.  
  751.         err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  752.         if (noErr != err) goto done;
  753.  
  754.         err = CreateObjSpecifier(cText, &docSpec, formRange, &rangeDesc, false, result);
  755.     }
  756.     else
  757.         err = AEDuplicateDesc(&startSpec, result);
  758.     
  759. done:
  760.     (void)AEDisposeDesc(&docSpec);
  761.     (void)AEDisposeDesc(&startSpec);
  762.     (void)AEDisposeDesc(&endSpec);
  763.     (void)AEDisposeDesc(&rangeDesc);
  764.  
  765.     return(err);
  766. }
  767.